ஜாவாஸ்கிரிப்ட் ஃபங்ஷன் அழைப்புகளுக்கான ஆப்சனல் செயினிங்: பாதுகாப்பான மெத்தட் அழைப்பிற்கான உலகளாவிய வழிகாட்டி

தொடர்ந்து மாறிவரும் வலை மேம்பாட்டுத் துறையில், நம்பகமான மற்றும் பிழையற்ற குறியீட்டை எழுதுவது மிகவும் முக்கியமானது. உலகெங்கிலும் உள்ள டெவலப்பர்கள் சிக்கலான செயலிகளை உருவாக்கும்போது, சாத்தியமான தரவு அல்லது ஆப்ஜெக்ட்கள் இல்லாத நிலையைச் சமாளிப்பது ஒரு பொதுவான சவாலாக உள்ளது. இந்தச் சிக்கலைத் தீர்க்க நவீன ஜாவாஸ்கிரிப்டில் (ES2020) அறிமுகப்படுத்தப்பட்ட நேர்த்தியான தீர்வுகளில் ஒன்றுதான் ஆப்சனல் செயினிங், குறிப்பாக ஃபங்ஷன்கள் அல்லது மெத்தட்களைப் பாதுகாப்பாக அழைப்பதில் அதன் பயன்பாடு. இந்த வழிகாட்டி, ஃபங்ஷன் அழைப்புகளுக்கான ஆப்சனல் செயினிங் எவ்வாறு உலகெங்கிலும் உள்ள டெவலப்பர்களுக்குத் தூய்மையான, மேலும் நெகிழ்வான குறியீட்டை எழுத உதவுகிறது என்பதை விளக்குகிறது.

பிரச்சனை: பூஜ்யப் படுகுழியில் பயணித்தல்

ஆப்சனல் செயினிங்கிற்கு முன்பு, டெவலப்பர்கள் பெரும்பாலும் நீளமான நிபந்தனைச் சோதனைகள் அல்லது && ஆபரேட்டரை நம்பியிருந்தனர். ஒருவேளை null அல்லது undefined ஆக இருக்கக்கூடிய ஆப்ஜெக்ட்களில் உள்ள பண்புகளை அணுகுவதற்கோ அல்லது மெத்தட்களை அழைப்பதற்கோ இது பயன்படுத்தப்பட்டது. ஒரு API-யிலிருந்து பெறப்பட்ட அல்லது டைனமிக்காக உருவாக்கப்பட்ட உள்ளமைந்த தரவுக் கட்டமைப்புகள் உங்களிடம் இருப்பதாகக் கருதுங்கள்.

ஒரு பயனர் சுயவிவர ஆப்ஜெக்டில் முகவரி இருக்கலாம் அல்லது இல்லாமலும் இருக்கலாம், அப்படி இருந்தால், அந்த முகவரியில் `getFormattedAddress` என்ற மெத்தட் இருக்கலாம் என்று கற்பனை செய்து கொள்ளுங்கள். பாரம்பரிய ஜாவாஸ்கிரிப்டில், முன்கூட்டியே சோதனைகள் செய்யாமல் இந்த மெத்தடை அழைக்க முயற்சித்தால், அது இதுபோன்று இருக்கும்:

            let user = {
  name: "Alice",
  address: {
    street: "123 Main St",
    city: "Anytown",
    getFormattedAddress: function() {
      return `${this.street}, ${this.city}`;
    }
  }
};

// Scenario 1: Address and method exist
if (user && user.address && typeof user.address.getFormattedAddress === 'function') {
  console.log(user.address.getFormattedAddress()); // "123 Main St, Anytown"
}

// Scenario 2: User object is null
let nullUser = null;
if (nullUser && nullUser.address && typeof nullUser.address.getFormattedAddress === 'function') {
  console.log(nullUser.address.getFormattedAddress()); // Does not log, gracefully handles null user
}

// Scenario 3: Address is missing
let userWithoutAddress = {
  name: "Bob"
};
if (userWithoutAddress && userWithoutAddress.address && typeof userWithoutAddress.address.getFormattedAddress === 'function') {
  console.log(userWithoutAddress.address.getFormattedAddress()); // Does not log, gracefully handles missing address
}

// Scenario 4: Method is missing
let userWithAddressNoMethod = {
  name: "Charlie",
  address: {
    street: "456 Oak Ave",
    city: "Otherville"
  }
};
if (userWithAddressNoMethod && userWithAddressNoMethod.address && typeof userWithAddressNoMethod.address.getFormattedAddress === 'function') {
  console.log(userWithAddressNoMethod.address.getFormattedAddress()); // Does not log, gracefully handles missing method
}

            

              
                Copy
              
            
          

நீங்கள் பார்ப்பது போல, இந்தச் சோதனைகள் மிகவும் நீளமாக மாறக்கூடும், குறிப்பாக ஆழமாக உள்ளமைந்த ஆப்ஜெக்ட்களுடன். ஒவ்வொரு உள்ளமைவு நிலைக்கும் TypeError: Cannot read properties of undefined (reading '...') அல்லது TypeError: ... is not a function போன்ற பிழைகளைத் தடுக்க ஒரு கூடுதல் சோதனை தேவைப்படுகிறது.

ஆப்சனல் செயினிங் (?.) அறிமுகம்

ஆப்ஜெக்ட்களின் சங்கிலிக்குள் உள்ளமைந்திருக்கக்கூடிய பண்புகளை அணுகுவதற்கோ அல்லது மெத்தட்களை அழைப்பதற்கோ ஆப்சனல் செயினிங் ஒரு சுருக்கமான மற்றும் படிக்க எளிதான வழியை வழங்குகிறது. இந்தச் சங்கிலியின் எந்தப் பகுதியும் null அல்லது undefined ஆக இருக்கலாம். இதன் தொடரியல் ?. ஆபரேட்டரைப் பயன்படுத்துகிறது.

?. ஆபரேட்டர் அதன் இடது பக்கத்தில் null அல்லது undefined ஐ சந்திக்கும்போது, அது உடனடியாக வெளிப்பாட்டை மதிப்பிடுவதை நிறுத்திவிட்டு, ஒரு பிழையை உண்டாக்குவதற்குப் பதிலாக undefined ஐத் திருப்பியளிக்கிறது.

ஃபங்ஷன் அழைப்புகளுக்கான ஆப்சனல் செயினிங் (?.())

ஃபங்ஷன் அழைப்புகளுக்கான ஆப்சனல் செயினிங்கின் உண்மையான சக்தி, ஒரு மெத்தடைப் பாதுகாப்பாக அழைக்கும் அதன் திறனில் உள்ளது. இது ஃபங்ஷன் அழைப்பின் அடைப்புக்குறிக்கு () முன் நேரடியாக ?. ஆபரேட்டரைச் சேர்ப்பதன் மூலம் அடையப்படுகிறது.

பயனர் சுயவிவர உதாரணத்தை மீண்டும் பார்ப்போம், இம்முறை ஆப்சனல் செயினிங்கைப் பயன்படுத்தி:

            let user = {
  name: "Alice",
  address: {
    street: "123 Main St",
    city: "Anytown",
    getFormattedAddress: function() {
      return `${this.street}, ${this.city}`;
    }
  }
};

let nullUser = null;

let userWithoutAddress = {
  name: "Bob"
};

let userWithAddressNoMethod = {
  name: "Charlie",
  address: {
    street: "456 Oak Ave",
    city: "Otherville"
  }
};

// Safely calling the method using optional chaining
console.log(user?.address?.getFormattedAddress?.()); // "123 Main St, Anytown"
console.log(nullUser?.address?.getFormattedAddress?.()); // undefined
console.log(userWithoutAddress?.address?.getFormattedAddress?.()); // undefined
console.log(userWithAddressNoMethod?.address?.getFormattedAddress?.()); // undefined

            

              
                Copy
              
            
          

வித்தியாசத்தைக் கவனியுங்கள்:

• user?.address?.getFormattedAddress?.(): getFormattedAddress என்பதற்கு முன்னால் உள்ள ?., user.address என்பது null அல்லது undefined இல்லை என்பதைச் சரிபார்க்கிறது. அது சரியானதாக இருந்தால், user.address.getFormattedAddress இருக்கிறதா மற்றும் அது ஒரு ஃபங்ஷனா என்பதைச் சரிபார்க்கிறது. இரண்டு நிபந்தனைகளும் பூர்த்தி செய்யப்பட்டால், ஃபங்ஷன் அழைக்கப்படுகிறது. இல்லையெனில், அது ஷார்ட்-சர்க்யூட் செய்து undefined ஐத் திருப்பியளிக்கிறது.
• ?.() தொடரியல் மிகவும் முக்கியமானது. நீங்கள் user?.address?.getFormattedAddress() மட்டும் பயன்படுத்தியிருந்தால், getFormattedAddress என்பது undefined ஆகவோ அல்லது ஒரு ஃபங்ஷனாக இல்லாமலோ இருந்தால், அது இன்னும் ஒரு பிழையை உண்டாக்கும். இறுதி ?.() அந்த அழைப்பே பாதுகாப்பானது என்பதை உறுதி செய்கிறது.

முக்கிய சூழ்நிலைகள் மற்றும் சர்வதேசப் பயன்பாடுகள்

உலகளாவிய மென்பொருள் மேம்பாட்டிற்குப் பொதுவான சூழ்நிலைகளில், ஃபங்ஷன் அழைப்புகளுக்கான ஆப்சனல் செயினிங் மிகவும் மதிப்புமிக்கது:

1. API தரவு கையாளுதல்

நவீன செயலிகள் API-களிலிருந்து பெறப்படும் தரவை பெரிதும் சார்ந்துள்ளன. இந்த API-கள் முழுமையற்ற தரவை வழங்கலாம் அல்லது குறிப்பிட்ட புலங்கள் பயனர் உள்ளீடு அல்லது பிராந்திய அமைப்புகளைப் பொறுத்து விருப்பத்திற்குரியதாக இருக்கலாம். உதாரணமாக, ஒரு உலகளாவிய இ-காமர்ஸ் தளம் தயாரிப்பு விவரங்களைப் பெறலாம். சில தயாரிப்புகளில் விருப்பத்திற்குரிய `getDiscountedPrice` மெத்தட் இருக்கலாம், மற்றவற்றில் இல்லாமல் இருக்கலாம்.

            async function fetchProductDetails(productId) {
  try {
    const response = await fetch(`/api/products/${productId}`);
    const product = await response.json();
    return product;
  } catch (error) {
    console.error("Failed to fetch product details:", error);
    return null;
  }
}

// Example usage:
async function displayProductInfo(id) {
  const product = await fetchProductDetails(id);

  if (product) {
    console.log(`Product Name: ${product.name}`);

    // Safely get and display discounted price if available
    const priceDisplay = product?.getDiscountedPrice?.() ?? 'Price unavailable';
    console.log(`Price: ${priceDisplay}`);
  } else {
    console.log("Product not found.");
  }
}

// Assume 'product' object might look like:
// {
//   name: "Global Widget",
//   basePrice: 100,
//   getDiscountedPrice: function() { return this.basePrice * 0.9; }
// }
// Or:
// {
//   name: "Basic Item",
//   basePrice: 50
// }

            

              
                Copy
              
            
          

சர்வதேசப் பயன்பாடுகளுக்கு இந்த முறை மிகவும் முக்கியமானது, ஏனெனில் தரவுக் கட்டமைப்புகள் பிராந்தியங்கள் அல்லது தயாரிப்பு வகைகளுக்கு இடையில் கணிசமாக வேறுபடலாம். வெவ்வேறு நாடுகளில் உள்ள பயனர்களுக்குச் சேவை செய்யும் ஒரு API, சற்றே மாறுபட்ட தரவுத் திட்டங்களை வழங்கக்கூடும், இது ஆப்சனல் செயினிங்கை ஒரு நம்பகமான தீர்வாக மாற்றுகிறது.

2. மூன்றாம் தரப்பு லைப்ரரி ஒருங்கிணைப்புகள்

மூன்றாம் தரப்பு லைப்ரரிகள் அல்லது SDK-களுடன் ஒருங்கிணைக்கும்போது, குறிப்பாக உலகளாவிய பார்வையாளர்களுக்காக வடிவமைக்கப்பட்டவற்றில், அவற்றின் உள் கட்டமைப்பு அல்லது அவை எவ்வாறு உருவாகின்றன என்பதில் உங்களுக்கு முழுமையான கட்டுப்பாடு இருக்காது. ஒரு லைப்ரரி சில உள்ளமைவுகள் அல்லது பதிப்புகளின் கீழ் மட்டுமே கிடைக்கும் மெத்தட்களை வெளிப்படுத்தக்கூடும்.

            // Assume 'analytics' is an SDK object
// It might have a 'trackEvent' method, but not always.
// e.g., analytics.trackEvent('page_view', { url: window.location.pathname });

// Safely call the tracking function
analytics?.trackEvent?.('user_login', { userId: currentUser.id });

            

              
                Copy
              
            
          

பயனர் வெவ்வேறு தரவு தனியுரிமை விதிமுறைகளைக் கொண்ட ஒரு பிராந்தியத்தில் இருந்தால், அனலிட்டிக்ஸ் SDK தொடங்கப்படவில்லை, ஏற்றப்படவில்லை, அல்லது நீங்கள் அழைக்க முயற்சிக்கும் குறிப்பிட்ட மெத்தடை வெளிப்படுத்தவில்லை என்றால், இது உங்கள் செயலி செயலிழப்பதைத் தடுக்கிறது.

3. நிகழ்வு கையாளுதல் மற்றும் கால்பேக்குகள்

சிக்கலான பயனர் இடைமுகங்களில் அல்லது ஒத்திசைவற்ற செயல்பாடுகளைக் கையாளும்போது, கால்பேக் ஃபங்ஷன்கள் அல்லது நிகழ்வு கையாளிகள் விருப்பத்திற்குரியதாக இருக்கலாம். உதாரணமாக, ஒரு UI கூறு விருப்பத்திற்குரிய `onUpdate` கால்பேக்கை ஏற்கலாம்.

            
class DataFetcher {
  constructor(options = {}) {
    this.onFetchComplete = options.onFetchComplete; // This could be a function or undefined
  }

  fetchData() {
    // ... perform fetch operation ...
    const data = { message: "Data successfully fetched" };

    // Safely call the callback if it exists
    this.onFetchComplete?.(data);
  }
}

// Usage 1: With a callback
const fetcherWithCallback = new DataFetcher({
  onFetchComplete: (result) => {
    console.log("Fetch completed with data:", result);
  }
});
fetcherWithCallback.fetchData();

// Usage 2: Without a callback
const fetcherWithoutCallback = new DataFetcher();
fetcherWithoutCallback.fetchData(); // No error, as onFetchComplete is undefined

            

              
                Copy
              
            
          

ஒவ்வொரு விருப்பத்திற்குரிய கையாளியையும் வழங்கும்படி டெவலப்பர்களைக் கட்டாயப்படுத்தாமல், பல்வேறு சூழல்களில் பயன்படுத்தக்கூடிய நெகிழ்வான கூறுகளை உருவாக்க இது அவசியமானது.

4. உள்ளமைவு ஆப்ஜெக்ட்கள்

செயலிகள் பெரும்பாலும் உள்ளமைவு ஆப்ஜெக்ட்களைப் பயன்படுத்துகின்றன, குறிப்பாக சர்வதேசமயமாக்கல் (i18n) அல்லது உள்ளூர்மயமாக்கல் (l10n) கையாளும்போது. ஒரு உள்ளமைவு, இருக்கலாம் அல்லது இல்லாமல் இருக்கலாம் என்று தனிப்பயன் வடிவமைப்பு ஃபங்ஷன்களைக் குறிப்பிடலாம்.

            const appConfig = {
  locale: "en-US",
  // customNumberFormatter might be present or absent
  customNumberFormatter: (num) => `$${num.toFixed(2)}`
};

function formatCurrency(amount, config) {
  // Safely use custom formatter if it exists, otherwise use default
  const formatter = config?.customNumberFormatter ?? ((n) => n.toLocaleString());
  return formatter(amount);
}

console.log(formatCurrency(1234.56, appConfig)); // Uses custom formatter

const basicConfig = { locale: "fr-FR" };
console.log(formatCurrency(7890.12, basicConfig)); // Uses default formatter

            

              
                Copy
              
            
          

ஒரு உலகளாவிய செயலியில், வெவ்வேறு இடங்கள் மிகவும் மாறுபட்ட வடிவமைப்பு மரபுகளைக் கொண்டிருக்கலாம், மேலும் பிராந்தியங்கள் முழுவதும் தடையற்ற பயனர் அனுபவத்திற்கு ஆப்சனல் செயினிங் மூலம் பின்னடைவு வழிமுறைகளை வழங்குவது மிகவும் முக்கியமானது.

ஆப்சனல் செயினிங்கை நல்லிஷ் கோலெஸ்சிங்குடன் (??) இணைத்தல்

ஆப்சனல் செயினிங் இல்லாத மதிப்புகளை undefined என்று திருப்பி அளித்து நேர்த்தியாகக் கையாளும் அதே வேளையில், நீங்கள் பெரும்பாலும் அதற்குப் பதிலாக ஒரு இயல்புநிலை மதிப்பை வழங்க விரும்புவீர்கள். இங்குதான் நல்லிஷ் கோலெஸ்சிங் ஆபரேட்டர் (??) பிரகாசிக்கிறது, இது ஆப்சனல் செயினிங்குடன் தடையின்றி செயல்படுகிறது.

?? ஆபரேட்டர் அதன் இடது கை ஆபராண்டை அது null அல்லது undefined இல்லை என்றால் திருப்பி அளிக்கும்; இல்லையெனில், அது அதன் வலது கை ஆபராண்டை திருப்பி அளிக்கும்.

நமது பயனர் உதாரணத்தை மீண்டும் கருத்தில் கொள்வோம். `getFormattedAddress` மெத்தட் இல்லை என்றால், நாம் "முகவரித் தகவல் கிடைக்கவில்லை" போன்ற ஒரு இயல்புநிலைச் செய்தியைக் காட்ட விரும்பலாம்.

            let user = {
  name: "Alice",
  address: {
    street: "123 Main St",
    city: "Anytown",
    getFormattedAddress: function() {
      return `${this.street}, ${this.city}`;
    }
  }
};

let userWithAddressNoMethod = {
  name: "Charlie",
  address: {
    street: "456 Oak Ave",
    city: "Otherville"
  }
};

// Using optional chaining and nullish coalescing
const formattedAddress = user?.address?.getFormattedAddress?.() ?? "Address details missing";
console.log(formattedAddress); // "123 Main St, Anytown"

const formattedAddressMissing = userWithAddressNoMethod?.address?.getFormattedAddress?.() ?? "Address details missing";
console.log(formattedAddressMissing); // "Address details missing"

            

              
                Copy
              
            
          

பல்வகைப்பட்ட உலகளாவிய பயனர் தளத்தைக் கொண்ட செயலிகளில் பொதுவான தேவையாக இருக்கும் தரவு அல்லது செயல்பாடு எதிர்பார்க்கப்பட்டு, ஆனால் கிடைக்காதபோது, பயனர் நட்பான இயல்புநிலைகளை வழங்குவதற்கு இந்த இணைப்பு நம்பமுடியாத அளவிற்கு சக்தி வாய்ந்தது.

உலகளாவிய மேம்பாட்டிற்கான சிறந்த நடைமுறைகள்

ஒரு உலகளாவிய சூழலில் ஃபங்ஷன் அழைப்புகளுக்கு ஆப்சனல் செயினிங்கைப் பயன்படுத்தும்போது, இந்த சிறந்த நடைமுறைகளைக் கவனத்தில் கொள்ளுங்கள்:

• தெளிவாக இருங்கள்: ஆப்சனல் செயினிங் குறியீட்டைச் சுருக்கினாலும், குறியீட்டின் நோக்கம் தெளிவற்றதாக மாறும் அளவிற்கு அதை அதிகமாகப் பயன்படுத்த வேண்டாம். முக்கியமான சோதனைகள் இன்னும் தெளிவாக இருப்பதை உறுதி செய்யுங்கள்.
• நல்லிஷ் மற்றும் ஃபால்ஸிக்கு இடையிலான வேறுபாட்டைப் புரிந்து கொள்ளுங்கள்: ?. என்பது null மற்றும் undefined ஐ மட்டுமே சரிபார்க்கிறது என்பதை நினைவில் கொள்ளுங்கள். இது 0, '' (வெற்றுச் சரம்) அல்லது false போன்ற பிற ஃபால்ஸி மதிப்புகளுக்கு ஷார்ட்-சர்க்யூட் செய்யாது. நீங்கள் இவற்றை கையாள வேண்டுமென்றால், கூடுதல் சோதனைகள் அல்லது லாஜிக்கல் OR ஆபரேட்டர் (||) தேவைப்படலாம், இருப்பினும் இல்லாத மதிப்புகளைக் கையாள்வதற்கு ?? பொதுவாக விரும்பப்படுகிறது.
• அர்த்தமுள்ள இயல்புநிலைகளை வழங்குங்கள்: குறிப்பாக பயனர் எதிர்கொள்ளும் வெளியீட்டிற்கு, நல்லிஷ் கோலெஸ்சிங்கை (??) பயன்படுத்திப் புத்திசாலித்தனமான இயல்புநிலை மதிப்புகளை வழங்குங்கள். "அர்த்தமுள்ள இயல்புநிலை" என்பது இலக்கு பார்வையாளர்களின் கலாச்சாரச் சூழல் மற்றும் எதிர்பார்ப்புகளைப் பொறுத்தது.
• முழுமையான சோதனை: உங்கள் குறியீட்டை பல்வேறு தரவுச் சூழ்நிலைகளுடன், அதாவது இல்லாத பண்புகள், இல்லாத மெத்தட்கள், மற்றும் null/undefined மதிப்புகள் போன்றவற்றை, சாத்தியமானால் வெவ்வேறு சர்வதேசச் சூழல்களில் சோதிக்கவும்.
• ஆவணப்படுத்தல்: உங்கள் API அல்லது உள் கூறுகளின் எந்தப் பகுதிகள் விருப்பத்திற்குரியவை மற்றும் அவை இல்லாதபோது எவ்வாறு செயல்படுகின்றன என்பதைத் தெளிவாக ஆவணப்படுத்துங்கள், குறிப்பாக வெளிப்புறப் பயன்பாட்டிற்காக உருவாக்கப்பட்ட லைப்ரரிகளுக்கு.
• செயல்திறன் தாக்கங்களைக் கருத்தில் கொள்ளுங்கள் (சிறியது): பொதுவாக இது மிகச்சிறியதாக இருந்தாலும், மிகவும் செயல்திறன் முக்கியத்துவம் வாய்ந்த லூப்களில் அல்லது மிக ஆழமான உள்ளமைவுகளில், அதிகப்படியான ஆப்சனல் செயினிங் கோட்பாட்டளவில் மேம்படுத்தப்பட்ட கைமுறை சோதனைகளுடன் ஒப்பிடும்போது ஒரு சிறிய மேல்நிலைச் செலவைக் கொண்டிருக்கக்கூடும். இருப்பினும், பெரும்பாலான செயலிகளுக்கு, வாசிப்புத்திறன் மற்றும் நம்பகத்தன்மை ஆதாயங்கள் எந்தவொரு செயல்திறன் கவலைகளையும் விட அதிகமாகும்.

முடிவுரை

ஜாவாஸ்கிரிப்டின் ஆப்சனல் செயினிங், குறிப்பாகப் பாதுகாப்பான ஃபங்ஷன் அழைப்புகளுக்கான ?.() தொடரியல், தூய்மையான, மேலும் நெகிழ்வான குறியீட்டை எழுதுவதற்கான ஒரு குறிப்பிடத்தக்க முன்னேற்றமாகும். தரவுக் கட்டமைப்புகள் பன்முகத்தன்மை கொண்ட மற்றும் கணிக்க முடியாத ஒரு உலகளாவிய பார்வையாளர்களுக்காக செயலிகளை உருவாக்கும் டெவலப்பர்களுக்கு, இந்த அம்சம் ஒரு வசதி மட்டுமல்ல, ஒரு தேவையாகும். ஆப்சனல் செயினிங்கை ஏற்றுக்கொள்வதன் மூலம், நீங்கள் ரன்டைம் பிழைகளின் சாத்தியக்கூறுகளை வியத்தகு முறையில் குறைக்கலாம், குறியீட்டின் வாசிப்புத்திறனை மேம்படுத்தலாம், மற்றும் சர்வதேசத் தரவு மற்றும் பயனர் தொடர்புகளின் சிக்கல்களை நேர்த்தியாகக் கையாளும் மேலும் நம்பகமான செயலிகளை உருவாக்கலாம்.

ஆப்சனல் செயினிங்கில் தேர்ச்சி பெறுவது, இணைக்கப்பட்ட உலகின் சவால்களை எதிர்கொள்ளும் நவீன, தொழில்முறை ஜாவாஸ்கிரிப்ட் எழுதுவதற்கான ஒரு முக்கிய படியாகும். இது சாத்தியமில்லாத பண்புகளை அணுகுவதற்கோ அல்லது இல்லாத மெத்தட்களை அழைப்பதற்கோ "தேர்வு செய்ய" உங்களை அனுமதிக்கிறது, உங்கள் செயலிகள் அவை எதிர்கொள்ளும் தரவைப் பொருட்படுத்தாமல் நிலையானதாகவும் கணிக்கக்கூடியதாகவும் இருப்பதை உறுதி செய்கிறது.